package dw.fastfile.common.dto.sync;

import com.google.common.collect.Lists;
import lombok.Getter;
import lombok.Setter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;

/**
 * @description: 同步数据
 * @author: wanghao
 * @create: 2022-07-01 14:24
 **/
@Getter
@Setter
public abstract class AbstractSyncData<T> {
    private String tenantId;
    private String ytenantId;
    private String creator;


    /**
     * 唯一性，用于redis，解决分布式定时任务问题。比如同步目标表
     *
     * @return key
     */
    protected String redisKey() {
        return this.getClass().getSimpleName();
    }

    /**
     * 获取源数据sql
     *
     * @return sql
     */
    protected abstract String getSaveDataSql();

    /**
     * 获取源数据update sql
     *
     * @return sql
     */
    protected abstract String getUpdateDataSql();

    /**
     * 根据数据库返回值，创建数据对象
     *
     * @param m
     * @return
     */
    protected abstract T createDataByMap(Map<String, Object> m);

    /**
     * 保存用友
     *
     * @param jdbcTemplate jdbc
     * @param data         数据体
     */
    protected abstract void saveTarget(JdbcTemplate jdbcTemplate, T data);

    /**
     * 更新用友
     *
     * @param jdbcTemplate jdbc
     * @param data         数据体
     */
    protected abstract void updateTarget(JdbcTemplate jdbcTemplate, T data);

    /**
     * 获取新增源数据
     *
     * @param jdbcTemplate jdbc
     * @return 源数据列表
     */
    protected List<T> getSourceSaveData(JdbcTemplate jdbcTemplate) {
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(this.getSaveDataSql());
        return getTs(maps);
    }

    /**
     * 获取修改源数据
     *
     * @param jdbcTemplate jdbc
     * @return 源数据列表
     */
    protected List<T> getSourceUpdateData(JdbcTemplate jdbcTemplate) {
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(this.getUpdateDataSql());
        return getTs(maps);
    }

    private List<T> getTs(List<Map<String, Object>> maps) {
        List<T> list = Lists.newArrayList();

        if (CollectionUtils.isEmpty(maps)) {
            return list;
        }

        for (Map<String, Object> m : maps) {
            list.add(this.createDataByMap(m));
        }

        return list;
    }

    public void syncData(JdbcTemplate jdbcTemplate) {
        // 分布式锁
//        RedisManager redisCache = AppContext.cache();
//        boolean setnx = redisCache.setnx(this.redisKey(), "1", 60);
//        if (!setnx) {
//            return;
//        }
//        // 保存
//        this.saveYY(jdbcTemplate);
//        // 更新
//        this.updateYY(jdbcTemplate);
//
//        redisCache.del(this.redisKey());
    }

    public void save(JdbcTemplate jdbcTemplate) {
        // 1.从中间表查询新增数据
        List<T> dataList = this.getSourceSaveData(jdbcTemplate);
        if (CollectionUtils.isEmpty(dataList)) {
            return;
        }

        // 2.保存用友
        for (T data : dataList) {
            if (null != data) {
                this.saveTarget(jdbcTemplate, data);
            }
        }
    }

    public void update(JdbcTemplate jdbcTemplate) {
        // 1.从中间表查询修改的数据
        List<T> dataList = this.getSourceUpdateData(jdbcTemplate);
        if (CollectionUtils.isEmpty(dataList)) {
            return;
        }

        // 2.修改用友
        for (T data : dataList) {
            if (null != data) {
                this.updateTarget(jdbcTemplate, data);
            }
        }
    }

}
